/**
 * 
 */
package fr.gfi.agraf.vue.action.administrer.tache;

import java.util.ArrayList;
import java.util.List;

import fr.gfi.agraf.service.ITacheService;
import fr.gfi.agraf.utils.PropertiesUtils;
import fr.gfi.agraf.utils.SpringFactory;
import fr.gfi.agraf.utils.VerificationUtils;
import fr.gfi.agraf.vue.action.AbstractApplicationSupportAction;
import fr.gfi.agraf.vue.bean.TacheDTO;
import fr.gfi.agraf.vue.bean.UtilisateurDTO;

/**
 * @author Fw
 * 
 */
public class ModifierTachesAction extends AbstractApplicationSupportAction {

	/**
	 * Généré par Java
	 */
	private static final long serialVersionUID = -1955043724303152637L;

	private static final String ERREUR_DONNEES_INCOHERENTES = "erreur.donnees.incoherente.form";

	private static final String MESSAGE_TACHE_CORRECTEMENT_VALIDEE = "message.tache.correctement.modifiee";

	private static final String TACHE_SERVICE = "TacheService";

	private Long[] idTache;
	private String[] newLibelle;
	private String[] oldLibelle;
	private String[] newChargeInit;
	private String[] oldChargeInit;
	private String[] newCommentaire;
	private String[] oldCommentaire;
	private Long[] newAttrUtilisateur;
	private Long[] oldAttrUtilisateur;
	private Long[] supprTache;
	private Long activiteChoisi;

	private String[] libelleAdded;
	private String[] chargeInitAdded;
	private String[] commentaireAdded;
	private Long[] newAttrUtilisateurAdded;

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * fr.gfi.agraf.vue.action.AbstractApplicationSupportAction#executeAction()
	 */
	@Override
	public String executeAction() throws Exception {

		// Je vérifie les champs
		boolean isModification = false;
		if (VerificationUtils.checkAreInputTabsOk(newLibelle, oldLibelle, newChargeInit, oldChargeInit,
				newCommentaire, oldCommentaire, newAttrUtilisateur, oldAttrUtilisateur)) {
			if (VerificationUtils.checkAreInputTabsOkNotNull(newLibelle, oldLibelle, newChargeInit,
					oldChargeInit, newCommentaire, oldCommentaire, newAttrUtilisateur, oldAttrUtilisateur)) {
				isModification = true;
			}
		} else {
			addActionError(PropertiesUtils.getProperty(ERREUR_DONNEES_INCOHERENTES));
			return ERROR;
		}

		boolean isAjout = false;
		if (VerificationUtils.checkAreInputTabsOkNotNull(libelleAdded, chargeInitAdded, commentaireAdded,
				newAttrUtilisateurAdded)) {
			isAjout = true;
		}

		// Je prepare les listes à envoyer au manager
		List<TacheDTO> tacheToModif = null;
		if (isModification) {
			tacheToModif = new ArrayList<TacheDTO>();
			for (int i = 0; i < newLibelle.length; i++) {
				// Je verifie d'abord si elle n'est pas dans la liste des taches
				// a éffacées
				if (isIdToDelete(idTache[i])) {
					continue;
				}

				// Sinon je verifie qu'il existe des modifications
				final TacheDTO tacheNew = new TacheDTO();
				tacheNew.setId(idTache[i]);
				try {
					tacheNew.setChargeInit(Double.valueOf(newChargeInit[i].replace(',', '.')));
				} catch (final NumberFormatException e) {
					addActionError(PropertiesUtils.getProperty(ERREUR_DONNEES_INCOHERENTES));
					return ERROR;
				}
				tacheNew.setCommentaire(newCommentaire[i]);
				tacheNew.setLibelle(newLibelle[i]);
				final UtilisateurDTO userNew = new UtilisateurDTO();
				userNew.setId(newAttrUtilisateur[i]);
				tacheNew.setUtilisateur(userNew);

				final TacheDTO tacheOld = new TacheDTO();
				tacheOld.setId(idTache[i]);
				try {
					tacheOld.setChargeInit(Double.valueOf(oldChargeInit[i]));
				} catch (final NumberFormatException e) {
					addActionError(PropertiesUtils.getProperty(ERREUR_DONNEES_INCOHERENTES));
					return ERROR;
				}

				tacheOld.setCommentaire(oldCommentaire[i]);
				tacheOld.setLibelle(oldLibelle[i]);
				final UtilisateurDTO userOld = new UtilisateurDTO();
				userOld.setId(oldAttrUtilisateur[i]);
				tacheOld.setUtilisateur(userOld);

				if (existModification(tacheNew, tacheOld)) {
					tacheToModif.add(tacheNew);
				}

			}
		}

		List<TacheDTO> listeToAdd = null;
		if (isAjout) {
			listeToAdd = new ArrayList<TacheDTO>();
			for (int i = 0; i < libelleAdded.length; i++) {
				final TacheDTO tache = new TacheDTO();
				tache.setCommentaire(commentaireAdded[i]);
				tache.setLibelle(libelleAdded[i]);
				try {
					tache.setChargeInit(Double.valueOf(chargeInitAdded[i].replace(',', '.')));
				} catch (final NumberFormatException e) {
					addActionError(PropertiesUtils.getProperty(ERREUR_DONNEES_INCOHERENTES));
					return ERROR;
				}
				final UtilisateurDTO user = new UtilisateurDTO();
				user.setId(newAttrUtilisateurAdded[i]);
				tache.setUtilisateur(user);

				listeToAdd.add(tache);
			}
		}

		final ITacheService tacheService = (ITacheService) SpringFactory.getApplicationContext().getBean(
				TACHE_SERVICE);
		tacheService.enregistrerModificationTaches(listeToAdd, tacheToModif, supprTache, activiteChoisi);

		addActionMessage(PropertiesUtils.getProperty(MESSAGE_TACHE_CORRECTEMENT_VALIDEE));

		return SUCCESS;
	}

	/**
	 * Verifie si il y a eu des changements sur l'objet
	 * 
	 * @param tacheNew
	 * @param tacheOld
	 * @return
	 */
	private boolean existModification(final TacheDTO tacheNew, final TacheDTO tacheOld) {
		if (!tacheNew.getLibelle().equals(tacheOld.getLibelle())) {
			return true;
		}
		if (!tacheNew.getChargeInit().equals(tacheOld.getChargeInit())) {
			return true;
		}
		if (!tacheNew.getCommentaire().equals(tacheOld.getCommentaire())) {
			return true;
		}
		if (!tacheNew.getUtilisateur().getId().equals(tacheOld.getUtilisateur().getId())) {
			return true;
		}
		return false;
	}

	/**
	 * Dit si un id de tache est a supprimer ou non
	 * 
	 * @param id
	 * @return
	 */
	private boolean isIdToDelete(final Long id) {
		if (supprTache != null) {
			for (int i = 0; i < supprTache.length; i++) {
				if (supprTache[i] == id) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * @return the newLibelle
	 */
	public String[] getNewLibelle() {
		return newLibelle;
	}

	/**
	 * @param newLibelle
	 *            the newLibelle to set
	 */
	public void setNewLibelle(final String[] newLibelle) {
		this.newLibelle = newLibelle;
	}

	/**
	 * @return the oldLibelle
	 */
	public String[] getOldLibelle() {
		return oldLibelle;
	}

	/**
	 * @param oldLibelle
	 *            the oldLibelle to set
	 */
	public void setOldLibelle(final String[] oldLibelle) {
		this.oldLibelle = oldLibelle;
	}

	/**
	 * @return the newChargeInit
	 */
	public String[] getNewChargeInit() {
		return newChargeInit;
	}

	/**
	 * @param newChargeInit
	 *            the newChargeInit to set
	 */
	public void setNewChargeInit(final String[] newChargeInit) {
		this.newChargeInit = newChargeInit;
	}

	/**
	 * @return the oldChargeInit
	 */
	public String[] getOldChargeInit() {
		return oldChargeInit;
	}

	/**
	 * @param oldChargeInit
	 *            the oldChargeInit to set
	 */
	public void setOldChargeInit(final String[] oldChargeInit) {
		this.oldChargeInit = oldChargeInit;
	}

	/**
	 * @return the newCommentaire
	 */
	public String[] getNewCommentaire() {
		return newCommentaire;
	}

	/**
	 * @param newCommentaire
	 *            the newCommentaire to set
	 */
	public void setNewCommentaire(final String[] newCommentaire) {
		this.newCommentaire = newCommentaire;
	}

	/**
	 * @return the oldCommentaire
	 */
	public String[] getOldCommentaire() {
		return oldCommentaire;
	}

	/**
	 * @param oldCommentaire
	 *            the oldCommentaire to set
	 */
	public void setOldCommentaire(final String[] oldCommentaire) {
		this.oldCommentaire = oldCommentaire;
	}

	/**
	 * @return the supprTache
	 */
	public Long[] getSupprTache() {
		return supprTache;
	}

	/**
	 * @param supprTache
	 *            the supprTache to set
	 */
	public void setSupprTache(final Long[] supprTache) {
		this.supprTache = supprTache;
	}

	/**
	 * @return the activiteChoisi
	 */
	public Long getActiviteChoisi() {
		return activiteChoisi;
	}

	/**
	 * @param activiteChoisi
	 *            the activiteChoisi to set
	 */
	public void setActiviteChoisi(final Long activiteChoisi) {
		this.activiteChoisi = activiteChoisi;
	}

	/**
	 * @return the newAttrUtilisateur
	 */
	public Long[] getNewAttrUtilisateur() {
		return newAttrUtilisateur;
	}

	/**
	 * @param newAttrUtilisateur
	 *            the newAttrUtilisateur to set
	 */
	public void setNewAttrUtilisateur(final Long[] newAttrUtilisateur) {
		this.newAttrUtilisateur = newAttrUtilisateur;
	}

	/**
	 * @return the oldAttrUtilisateur
	 */
	public Long[] getOldAttrUtilisateur() {
		return oldAttrUtilisateur;
	}

	/**
	 * @param oldAttrUtilisateur
	 *            the oldAttrUtilisateur to set
	 */
	public void setOldAttrUtilisateur(final Long[] oldAttrUtilisateur) {
		this.oldAttrUtilisateur = oldAttrUtilisateur;
	}

	/**
	 * @return the libelleAdded
	 */
	public String[] getLibelleAdded() {
		return libelleAdded;
	}

	/**
	 * @param libelleAdded
	 *            the libelleAdded to set
	 */
	public void setLibelleAdded(final String[] libelleAdded) {
		this.libelleAdded = libelleAdded;
	}

	/**
	 * @return the chargeInitAdded
	 */
	public String[] getChargeInitAdded() {
		return chargeInitAdded;
	}

	/**
	 * @param chargeInitAdded
	 *            the chargeInitAdded to set
	 */
	public void setChargeInitAdded(final String[] chargeInitAdded) {
		this.chargeInitAdded = chargeInitAdded;
	}

	/**
	 * @return the commentaireAdded
	 */
	public String[] getCommentaireAdded() {
		return commentaireAdded;
	}

	/**
	 * @param commentaireAdded
	 *            the commentaireAdded to set
	 */
	public void setCommentaireAdded(final String[] commentaireAdded) {
		this.commentaireAdded = commentaireAdded;
	}

	/**
	 * @return the newAttrUtilisateurAdded
	 */
	public Long[] getNewAttrUtilisateurAdded() {
		return newAttrUtilisateurAdded;
	}

	/**
	 * @param newAttrUtilisateurAdded
	 *            the newAttrUtilisateurAdded to set
	 */
	public void setNewAttrUtilisateurAdded(final Long[] newAttrUtilisateurAdded) {
		this.newAttrUtilisateurAdded = newAttrUtilisateurAdded;
	}

	/**
	 * @return the idTache
	 */
	public Long[] getIdTache() {
		return idTache;
	}

	/**
	 * @param idTache
	 *            the idTache to set
	 */
	public void setIdTache(final Long[] idTache) {
		this.idTache = idTache;
	}

}
